const express = require('express')
const router = express.Router()
const md5 = require('md5');
const User = require('../models/userModel')
const FriendshipModel = require('../models/friendshipfModel')
const jw = require('jsonwebtoken')
const Chat = require('../models/chatModel')
const { secret } = require('../config/config')
const checkTokenMiddleware = require('../middlewares/checkTokenMiddleware')
// 注册用户
router.post('/register', (req, res) => {
    User.create({
        ...req.body,
        password: md5(req.body.password)
    })
        .then(doc => res.json({
            code: 200,
            message: '注册成功',
            data: doc,
            ok: true
        }))
        .catch(err => res.json({
            code: 203,
            message: err.message,
            data: null,
            ok: false
        }));
});
// 用户登录
router.post('/login', (req, res) => {
    // 解析前端传来的用户名和密码
    let { username, password } = req.body;
    User.findOne({ username: username, password: md5(password) })
        .then(doc => {
            // 创建当前用户的token
            let token = jw.sign({
                username: doc.username,
                _id: doc._id
            }, secret, {
                expiresIn: 60 * 60 * 24 * 7
            })
            res.json({
                code: 200,
                message: '登录成功',
                data: {
                    token,
                    username: doc.username,
                    _id: doc._id,
                    avatar: doc.avatar
                },
                ok: true
            })

        })
        .catch(err => res.json(
            {
                code: 203,
                message: err.message,
                data: null,
                ok: false
            }
        ))
})

// 获取全部或查询好友
// router.post('/friendsInfo',checkTokenMiddleware, async (req, res) => {
//     const { userId, keyword } = req.body;
//     try {
//         // 如果keyword，则添加一个查询条件
//         // 查找这个用户的所有好友关系，排除用户自己
//         const friendships = await FriendshipModel.find({
//             $or: [
//                 { userId: userId, status: 'accepted' },
//                 { friendId: userId, status: 'accepted' }
//             ],
//         });
//         console.log(friendships);
        

//         // 获取所有好友的ID，检查是 userId 还是 friendId
//         const friendIds = friendships.map(friendship => {
//             // 使用 ObjectId 的 equals 方法进行比较
//             return friendship.userId.toString() === userId.toString() ? friendship.friendId : friendship.userId;
//         });
//         console.log(friendIds);
        
//         // 根据好友ID获取用户信息
//         if (keyword) {
//             // 根据好友 ID 查询用户信息，做模糊匹配
//             const friends = await User.find(
//                 {
//                     _id: { $in: friendIds },
//                     ...(keyword ? { username: { $regex: keyword, $options: 'i' } } : {}) // 如果有 keyword，则做模糊匹配
//                 },
//                 'username avatar'
//             );
//             res.status(200).json({
//                 code: 200,
//                 message: '获取信息成功',
//                 data: friends,
//                 ok: true
//             });
//         }
//         else {
//             const friends = await User.find({ _id: { $in: friendIds } }, 'username avatar');
//             res.status(200).json({
//                 code: 200,
//                 message: '获取信息成功',
//                 data: friends,
//                 ok: true
//             });
//         }

//     } catch (error) {
//         res.status(500).send({
//             code: 203,
//             message: error.message,
//             data: null,
//             ok: false
//         });
//     }
// });
// 获取全部或查询好友
router.post('/friendsInfo', checkTokenMiddleware, async (req, res) => {
    const { userId, keyword } = req.body;
    try {
        // 查找这个用户的所有好友关系，排除用户自己
        const friendships = await FriendshipModel.find({
            $or: [
                { userId: userId, status: 'accepted' },
                { friendId: userId, status: 'accepted' }
            ],
        });
        console.log(friendships);

        // 获取所有好友的ID，检查是 userId 还是 friendId
        const friendIds = friendships.map(friendship => {
            return {
                roomName: friendship._id,  // 返回 Friendship 的 _id
                friendId: friendship.userId.toString() === userId.toString() ? friendship.friendId : friendship.userId
            };
        });
        console.log(friendIds);

        // 根据好友ID获取用户信息
        let friends;
        if (keyword) {
            // 根据好友 ID 查询用户信息，做模糊匹配
            friends = await User.find(
                {
                    _id: { $in: friendIds.map(friend => friend.friendId) }, // 使用 friendId 进行匹配
                    ...(keyword ? { username: { $regex: keyword, $options: 'i' } } : {}) // 如果有 keyword，则做模糊匹配
                },
                'username avatar'
            );
        } else {
            friends = await User.find({ _id: { $in: friendIds.map(friend => friend.friendId) } }, 'username avatar');
        }

        // 将 Friendship 的 _id 与 User 信息关联
        const response = friends.map(friend => {
            const friendship = friendIds.find(f => f.friendId.toString() === friend._id.toString());
            return {
                _id:friend._id,
                username: friend.username,
                avatar: friend.avatar,
                roomName: friendship ? friendship.roomName : null // 返回对应的 Friendship ID
            };
        });
        console.log(response);
        
        res.status(200).json({
            code: 200,
            message: '获取信息成功',
            data: response,
            ok: true
        });

    } catch (error) {
        res.status(500).send({
            code: 203,
            message: error.message,
            data: null,
            ok: false
        });
    }
});
// 获取用户的信息
router.post('/userInfo',checkTokenMiddleware, async (req, res) => {
    // 根据fid获取好友的头像，用户名，id
    const userId = req.body.userId;
    try {
        const userInfo = await User.findOne({ _id: userId }, 'username avatar')
        res.json({
            code: 200,
            message: '获取信息成功',
            data: userInfo,
            ok: true
        });
    } catch (error) {
        res.status(500).send({
            code: 203,
            message: error.message,
            data: null,
            ok: false
        });
    }


})
// 添加好友，同意好友
// 添加好友，同意好友
router.post('/addfriend',checkTokenMiddleware, async (req, res) => {
    const { userId, friendId } = req.body;
    try {
        // 检查是否已经存在好友关系
        const existingFriendship = await FriendshipModel.findOne({
            $or: [
                { userId: userId, friendId: friendId },
                { userId: friendId, friendId: userId }
            ]
        });
        console.log(existingFriendship);

        if (existingFriendship) {
            // 如果是 userId 向 friendId 发送的申请，状态为 'pending'，则更新为 'accepted'
            if (existingFriendship.userId.toString() === userId.toString()) {

                // 返回已发送申请的提示
                return res.send({
                    code: 200,
                    message: '已发送好友申请',
                    data: null,
                    ok: false
                });
            }
            // 如果是 friendId 向 userId 发送的申请，更新状态为 'accepted'
            if (existingFriendship.userId.toString() === friendId.toString() && existingFriendship.status === 'pending') {


                existingFriendship.status = 'accepted';
                await existingFriendship.save();
                return res.send({
                    code: 200,
                    message: '已同意好友申请',
                    data: null,
                    ok: true
                });
            }
        } else {

            // 如果不存在，创建新的好友关系
            const newFriendship = new FriendshipModel({
                userId: userId,
                friendId: friendId,
                status: 'pending' // 状态默认为待处理
            });
            await newFriendship.save();
            return res.send({
                code: 200,
                message: '好友申请已发送',
                data: null,
                ok: true
            });
        }

    } catch (error) {
        res.status(500).send({
            code: 203,
            message: error.message,
            data: null,
            ok: false
        });
    }
});
// 获取好友申请
router.post('/newfriends',checkTokenMiddleware, async (req, res) => {
    try {
        const { userId } = req.body;

        // Step 1: 查找好友请求的记录，查询 friendId = userId 的记录，并返回 status 字段
        const friendshipRequests = await FriendshipModel.find({ friendId: userId });

        // Step 2: 提取出所有需要查询的 userId 和 status
        const friendIds = friendshipRequests.map(request => request.userId);
        const statuses = friendshipRequests.map(request => request.status); // 获取所有对应的状态


        // Step 3: 在用户表中查询这些 userId 的用户信息
        const users = await User.find({ _id: { $in: friendIds } }, 'username avatar');

        // Step 4: 将用户信息和状态结合起来
        const result = users.map(user => {
            const index = friendIds.findIndex(id => id.equals(user._id)); // 使用 equals() 方法
            return {
                ...user._doc, // 复制用户信息
                status: statuses[index] // 添加对应的 status
            };
        });


        // Step 5: 返回包含用户信息和状态的数据
        res.status(200).json({
            code: 200,
            message: '获取所有好友申请',
            data: result,
            ok: true
        });
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Server error" });
    }
})
// 搜索用户
router.post('/searchUsers',checkTokenMiddleware, async (req, res) => {
    const { userId, friendname } = req.body;
    try {
        // 在User模糊查询，返回用户avatar username _id
        // 在User模型中进行模糊查询
        const users = await User.find({
            username: { $regex: friendname, $options: 'i' },// 忽略大小写
            _id: { $ne: userId }
        }).select('avatar username _id'); // 只返回avatar, username, _id字段

        // 如果找到了用户
        if (users.length > 0) {
            res.status(200).json({
                code: 200,
                message: '查询成功',
                data: users,
                ok: true
            });
        } else {
            res.status(404).send('没有找到匹配的用户');
        }
    } catch (error) {
        console.log(error);

        res.status(500).send('出错了');
    }
})
// 删除好友
router.post('/deletefriend',checkTokenMiddleware, async (req, res) => {
    const { userId, friendId } = req.body;
    try {
        // 1. 删除好友关系
        const friendshipDeleteResult = await FriendshipModel.deleteOne({
            $or: [
                { userId: userId, friendId: friendId },
                { userId: friendId, friendId: userId }
            ]
        });
        console.log(friendshipDeleteResult);
        
        // 2. 删除相关的聊天记录
        const chatDeleteResult = await Chat.deleteMany({
            $or: [
                { senderId: userId, receiverId: friendId },  // 查询发送者为userId，接收者为friendId的记录
                { senderId: friendId, receiverId: userId }   // 查询发送者为friendId，接收者为userId的记录
            ]
        });
        console.log(chatDeleteResult);
        
        // 3. 返回删除结果
        if (friendshipDeleteResult.deletedCount > 0 && chatDeleteResult.deletedCount > 0) {
            return res.status(200).json({
                code: 200,
                message: '删除成功，好友关系和聊天记录已删除',
                data: null,
                ok: true
            });
        } else if (friendshipDeleteResult.deletedCount > 0) {
            return res.status(200).json({
                code: 200,
                message: '删除成功，好友关系已删除，但没有找到相关的聊天记录',
                data: null,
                ok: true
            });
        } else {
            return res.status(404).json({
                code: 404,
                message: '未找到相关的好友关系',
                data: null,
                ok: false
            });
        }
    } catch (error) {
        console.error(error);
        res.status(500).json({
            code: 500,
            message: '删除失败，服务器错误',
            data: null,
            ok: false
        });
    }
});
module.exports = router